package com.mmy.service.permissionmenu.impl;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.mmy.controller.Common;
import com.mmy.dao.permission.TConstMenuRepository;
import com.mmy.dao.permission.VConstRoleMenuRepository;
import com.mmy.domain.permissionmenu.TConstMenu;
import com.mmy.domain.permissionmenu.VConstRoleMenu;
import com.mmy.domain.sys.TSysUser;
import com.mmy.service.permissionmenu.MenuService;

@Service
public class MenuServiceImpl implements MenuService {

	@Autowired
	TConstMenuRepository tConstMenuRepository;
	@Autowired
	VConstRoleMenuRepository vConstRoleMenuRepository;

//TODO delete
//	/**
//	 * 函数功能说明： 新建菜单
//	 *
//	 * @param 参数说明
//	 * @return 返回值说明 ：菜单对象
//	 * @throws 异常处理说明
//	 * @author 创建人 shangzl
//	 * @date 创建日期 2020-11-12
//	 */
//
//	public TConstMenu save(TConstMenu tConstMenu) {
//
//		return tConstMenuRepository.save(tConstMenu);
//	}

	/**
	 * 函数功能说明： 通过菜单ID查找菜单
	 *
	 * @param 参数说明
	 * @return 返回值说明 ：菜单对象
	 * @throws 异常处理说明
	 * @author 创建人 shangzl
	 * @date 创建日期 2020-11-12
	 */
	public TConstMenu findByMenuID(int iMenuID) {

		return tConstMenuRepository.findByMenuID(iMenuID);
	}

//TODO delete
//	/**
//	 * 函数功能说明： 通过菜单名称、菜单类型、不包含子菜单的情况分页查找前台菜单
//	 * 
//	 * @param 参数说明
//	 * @return 返回值说明 ：菜单集合
//	 * @throws 异常处理说明
//	 * @author 创建人 shangzl
//	 * @date 创建日期 2020-11-12
//	 */
//
//	public List<TConstMenu> findFrontByMenuName(String strMenuName, String strType, int iTempPageNo, int iPageSize) {
//
//		return tConstMenuRepository.findFrontByMenuName(strMenuName, strType, iTempPageNo, iPageSize);
//	}

//TODO delete
//	/**
//	 * 函数功能说明： 通过菜单名称、菜单类型、不包含子菜单的情况查找前台菜单数量
//	 * 
//	 * @param 参数说明
//	 * @return 返回值说明 ：int
//	 * @throws 异常处理说明
//	 * @author 创建人 shangzl
//	 * @date 创建日期 2020-11-12
//	 */
//	public int countFrontByMenuName(String strMenuName, String strType) {
//
//		return tConstMenuRepository.countFrontByMenuName(strMenuName, strType);
//	}

//TODO delete
//	/**
//	 * 函数功能说明： 通过菜单名称、菜单类型、包含子菜单的情况分页查找前台菜单
//	 * 
//	 * @param 参数说明
//	 * @return 返回值说明：菜单集合
//	 * @throws 异常处理说明
//	 * @author 创建人 shangzl
//	 * @date 创建日期 2020-11-12
//	 */
//
//	public List<TConstMenu> findFrontByMenuNameAndChild(String strMenuName, int iTempPageNo, int iPageSize) {
//
//		return tConstMenuRepository.findFrontByMenuNameAndChild(strMenuName, strMenuName, iTempPageNo, iPageSize);
//	}

//TODO delete
//	/**
//	 * 函数功能说明： 通过菜单名称、菜单类型、包含子菜单的情况查找前台菜单数量
//	 * 
//	 * @param 参数说明
//	 * @return 返回值说明 ：菜单集合
//	 * @throws 异常处理说明
//	 * @author 创建人 shangzl
//	 * @date 创建日期 2020-11-12
//	 */
//	public int countFrontByMenuNameAndChild(String strMenuName) {
//
//		return tConstMenuRepository.countFrontByMenuNameAndChild(strMenuName, strMenuName);
//	}

//TODO delete
//	/**
//	 * 函数功能说明： 通过菜单名称、菜单类型、不包含子菜单的情况分页查找后台菜单
//	 * 
//	 * @param 参数说明
//	 * @return 返回值说明 ：菜单集合
//	 * @throws 异常处理说明
//	 * @author 创建人 shangzl
//	 * @date 创建日期 2020-11-12
//	 */
//
//	public List<TConstMenu> findBackByMenuName(String strMenuName, String strType, int iTempPageNo, int iPageSize) {
//
//		return tConstMenuRepository.findBackByMenuName(strMenuName, strType, iTempPageNo, iPageSize);
//	}

//TODO delete
//	/**
//	 * 函数功能说明： 通过菜单名称、菜单类型、不包含子菜单的情况查找后台菜单数量
//	 * 
//	 * @param 参数说明
//	 * @return 返回值说明 ：int
//	 * @throws 异常处理说明
//	 * @author 创建人 shangzl
//	 * @date 创建日期 2020-11-12
//	 */
//	public int countBackByMenuName(String strMenuName, String strType) {
//
//		return tConstMenuRepository.countBackByMenuName(strMenuName, strType);
//	}

//TODO delete
//	/**
//	 * 函数功能说明： 通过菜单名称、菜单类型、包含子菜单的情况查找分页后台菜单
//	 * 
//	 * @param 参数说明
//	 * @return 返回值说明：菜单集合
//	 * @throws 异常处理说明
//	 * @author 创建人 shangzl
//	 * @date 创建日期 2020-11-12
//	 */
//	public List<TConstMenu> findBackByMenuNameAndChild(String strMenuName, int iTempPageNo, int iPageSize) {
//
//		return tConstMenuRepository.findBackByMenuNameAndChild(strMenuName, strMenuName, iTempPageNo, iPageSize);
//	}

//TODO delete
//	/**
//	 * 函数功能说明： 通过菜单名称、菜单类型、包含子菜单的情况查找后台菜单数量
//	 * 
//	 * @param 参数说明
//	 * @return 返回值说明 ：int
//	 * @throws 异常处理说明
//	 * @author 创建人 shangzl
//	 * @date 创建日期 2020-11-12
//	 */
//	public int countBackByMenuNameAndChild(String strMenuName) {
//
//		return tConstMenuRepository.countBackByMenuNameAndChild(strMenuName, strMenuName);
//	}

	/**
	 * 函数功能说明： 查找全部菜单
	 * 
	 * @param 参数说明
	 * @return 返回值说明 ：菜单集合
	 * @throws 异常处理说明
	 * @author 创建人 shangzl
	 * @date 创建日期 2020-11-12
	 */
	public List<TConstMenu> findAll() {

		return tConstMenuRepository.findAll();
	}

//TODO delete
//	/**
//	 * 函数功能说明： 获取最大菜单ID
//	 * 
//	 * @param 参数说明
//	 * @return 返回值说明 ：Object
//	 * @throws 异常处理说明
//	 * @author 创建人 shangzl
//	 * @date 创建日期 2020-11-12
//	 */
//
//	public Object getMaxMenuID() {
//
//		return tConstMenuRepository.getMaxMenuID();
//	}

//TODO delete
//	/**
//	 * 函数功能说明： 根据菜单ID删除菜单
//	 * 
//	 * @param 参数说明
//	 * @return 返回值说明 ：无返回值
//	 * @throws 异常处理说明
//	 * @author 创建人 shangzl
//	 * @date 创建日期 2020-11-12
//	 */
//	public void delMenu(List<Integer> iMenuID) {
//
//		tConstMenuRepository.delMenu(iMenuID);
//	}

	/**
	 * 函数功能说明： 查找不包含已有ID的菜单
	 * 
	 * @param 参数说明
	 * @return 返回值说明 ：菜单集合
	 * @throws 异常处理说明
	 * @author 创建人 shangzl
	 * @date 创建日期 2020-11-12
	 */
	public List<TConstMenu> findMenuNotInID(int iRoleID) {

		List<VConstRoleMenu> lstConstRoleMenu = vConstRoleMenuRepository.findByRoleID(iRoleID);

//		查找不包含已有id的菜单
		List<Integer> lstMenuID = new ArrayList<Integer>();
		for (int i = 0; i < lstConstRoleMenu.size(); i++) {
			lstMenuID.add(lstConstRoleMenu.get(i).getMenuID());
		}
		List<TConstMenu> lstConstMenu = tConstMenuRepository.findMenuNotInID(lstMenuID);

		return lstConstMenu;
	}

//TODO delete
//	/**
//	 * 函数功能说明： 新增菜单ID
//	 * 
//	 * @param 参数说明
//	 * @return 返回值说明 ：无返回值
//	 * @throws 异常处理说明
//	 * @author 创建人 shangzl
//	 * @date 创建日期 2020-11-12
//	 */
//	public void save(int menuID) {
//
//		tConstMenuRepository.save(menuID);
//	}

//TODO delete
//	/**
//	 * 函数功能说明： 获取最大排序
//	 * 
//	 * @param 参数说明
//	 * @return 返回值说明 ：Object
//	 * @throws 异常处理说明
//	 * @author 创建人 shangzl
//	 * @date 创建日期 2020-11-12
//	 */
//
//	public Object getMaxSort() {
//
//		return tConstMenuRepository.getMaxSort();
//	}

//TODO delete
//	/**
//	 * 函数功能说明： 获取前台菜单最大ID
//	 * 
//	 * @param 参数说明
//	 * @return 返回值说明 ：Object
//	 * @throws 异常处理说明
//	 * @author 创建人 shangzl
//	 * @date 创建日期 2020-11-12
//	 */
//	public Object getMaxFrontMenuID() {
//
//		return tConstMenuRepository.getMaxFrontMenuID();
//	}

//TODO delete
//	/**
//	 * 函数功能说明： 获取后台菜单最大ID
//	 * 
//	 * @param 参数说明
//	 * @return 返回值说明：Object
//	 * @throws 异常处理说明
//	 * @author 创建人 shangzl
//	 * @date 创建日期 2020-11-12
//	 */
//
//	public Object getMaxBackMenuID() {
//
//		return tConstMenuRepository.getMaxBackMenuID();
//	}

	/**
	 * 函数功能说明： 获取所有顶级菜单
	 * 
	 * @param 参数说明
	 * @return 返回值说明 ：菜单集合
	 * @throws 异常处理说明
	 * @author 创建人 shangzl
	 * @date 创建日期 2020-11-12
	 */
	public List<TConstMenu> findAllMenu() {

		return tConstMenuRepository.findAllMenu();
	}

//TODO delete
//	/**
//	 * 函数功能说明： 通过菜单名称、类型查找菜单
//	 * 
//	 * @param 参数说明
//	 * @return 返回值说明 ：菜单集合
//	 * @throws 异常处理说明
//	 * @author 创建人 shangzl
//	 * @date 创建日期 2020-11-12
//	 */
//	public List<TConstMenu> findByMenuName(String cMenuName, int iType) {
//
//		return tConstMenuRepository.findByMenuName(cMenuName, iType);
//	}

//TODO delete
//	/**
//	 * 函数功能说明： 通过菜单URL查找菜单
//	 * 
//	 * @param 参数说明
//	 * @return 返回值说明 ：菜单集合
//	 * @throws 异常处理说明
//	 * @author 创建人 shangzl
//	 * @date 创建日期 2020-11-12
//	 */
//	public List<TConstMenu> findByUrl(String strUrl) {
//
//		return tConstMenuRepository.findByUrl(strUrl);
//	}

//TODO delete
//	/**
//	 * 函数功能说明： 通过菜单ID查找菜单状态
//	 * 
//	 * @param 参数说明
//	 * @return 返回值说明 ：int
//	 * @throws 异常处理说明
//	 * @author 创建人 shangzl
//	 * @date 创建日期 2020-11-12
//	 */
//	public int findStateByUpMenuID(int iUpMenuID) {
//
//		return tConstMenuRepository.findStateByUpMenuID(iUpMenuID);
//	}

//TODO delete
//	/**
//	 * 函数功能说明： 通过排序查找菜单
//	 * 
//	 * @param 参数说明
//	 * @return 返回值说明 ：菜单对象
//	 * @throws 异常处理说明
//	 * @author 创建人 shangzl
//	 * @date 创建日期 2020-11-12
//	 */
//
//	public TConstMenu findBySort(int iSort) {
//
//		return tConstMenuRepository.findBySort((byte) iSort);
//	}

//TODO delete
//	/**
//	 * 函数功能说明： 通过上级菜单ID查找子菜单
//	 * 
//	 * @param 参数说明
//	 * @return 返回值说明 ：菜单集合
//	 * @throws 异常处理说明
//	 * @author 创建人 shangzl
//	 * @date 创建日期 2020-11-12
//	 */
//	public List<TConstMenu> findByUpMenuID(int iUpMenuID) {
//
//		return tConstMenuRepository.findByUpMenuID(iUpMenuID);
//	}

//TODO delete
//	/**
//	 * 函数功能说明： 通过上级菜单排序查找子菜单
//	 * 
//	 * @param 参数说明
//	 * @return 返回值说明 ：菜单对象
//	 * @throws 异常处理说明
//	 * @author 创建人 shangzl
//	 * @date 创建日期 2020-11-12
//	 */
//	public TConstMenu findBySortUpMenuID(int iSort, int iUpMenuID) {
//
//		return tConstMenuRepository.findBySortUpMenuID(iSort, iUpMenuID);
//	}

//TODO delete
//	/**
//	 * 函数功能说明：查找顶级菜单数量
//	 * 
//	 * @param 参数说明
//	 * @return 返回值说明 :菜单对象
//	 * @throws 异常处理说明
//	 * @author 创建人 shangzl
//	 * @date 创建日期 2020-11-12
//	 */
//	public int countUpMenu() {
//
//		return tConstMenuRepository.countUpMenu();
//	}

	/**
	 * 函数功能说明： 获取菜单最大ID
	 * 
	 * @param 参数说明
	 * @return 返回值说明 ：int
	 * @throws 异常处理说明
	 * @author 创建人 shangzl
	 * @date 创建日期 2020-11-12
	 */
	private int getMaxMenuID(int iState) {
		Object oMenuID = null;
		int iMenuID = 0;
		switch (iState) {
		case 1:
			oMenuID = tConstMenuRepository.getMaxFrontMenuID();
			iMenuID = 1001;
			break;
		case 2:
			oMenuID = tConstMenuRepository.getMaxBackMenuID();
			iMenuID = 3001;
			break;
		case 3:
			oMenuID = tConstMenuRepository.getMaxMenuID();
			iMenuID = 1101;
			break;
		}

		if (oMenuID != null) {
			iMenuID = (int) oMenuID + 1;
		}

		return iMenuID;
	}

	/**
	 * 函数功能说明： 新建菜单
	 * 
	 * @param 参数说明
	 * @return 返回值说明 ：无返回值
	 * @throws 异常处理说明
	 * @author 创建人 shangzl
	 * @date 创建日期 2020-11-12
	 */
	public void createMenu(TConstMenu tConstMenu, TSysUser tSysUser) {

		int iType = tConstMenu.getType();

		int iUpMenuID = tConstMenu.getUpMenuID();

		if (iType == 0) {

			int iState = tConstMenuRepository.findStateByUpMenuID(iUpMenuID);

			tConstMenu.setState((byte) iState);

		}
		int iMenuID = getMaxMenuID(tConstMenu.getState());
		tConstMenu.setMenuID(iMenuID);

		Object oSort = tConstMenuRepository.getMaxSort();

		if (oSort == null) {

			tConstMenu.setSort((byte) 1);
		} else {

			if (iType == 1) {

				tConstMenu.setSort((byte) ((byte) oSort + 1));

			} else if (iType == 0) {

				List<TConstMenu> lstConstMenu = tConstMenuRepository.findByUpMenuID(iUpMenuID);

				if (lstConstMenu.size() == 0) {
					tConstMenu.setSort((byte) 1);
				} else {
					tConstMenu.setSort((byte) (lstConstMenu.size() + 1));
				}
			}

		}

		tConstMenu.setCreateDate(new Date());
		tConstMenu.setCreator(tSysUser.getUserName());
		tConstMenuRepository.save(tConstMenu.getMenuID());
		tConstMenuRepository.save(tConstMenu);

	}

	/**
	 * 函数功能说明： 删除菜单
	 * 
	 * @param 参数说明
	 * @return 返回值说明 ：无返回值
	 * @throws 异常处理说明
	 * @author 创建人 shangzl
	 * @date 创建日期 2020-11-12
	 */
	public void delMenu(String checkList) {
		String[] arrChecked = checkList.split(",");
		List<Integer> lstMenuID = new ArrayList<>();

		for (String str : arrChecked) {
			lstMenuID.add(Integer.parseInt(str));
		}

		tConstMenuRepository.delMenu(lstMenuID);
	}

	/**
	 * 函数功能说明： 修改菜单
	 * 
	 * @param 参数说明
	 * @return 返回值说明 ：无返回值
	 * @throws 异常处理说明
	 * @author 创建人 shangzl
	 * @date 创建日期 2020-11-12
	 */

	public void updateMenu(TConstMenu tConstMenu, TSysUser tSysUser) {
		/* 定义一个新的实体类对象 */
		TConstMenu newConstMenu = tConstMenuRepository.findByMenuID(tConstMenu.getMenuID());
		newConstMenu.setMenuName(tConstMenu.getMenuName());
		newConstMenu.setUrl(tConstMenu.getUrl());
		newConstMenu.setSort(tConstMenu.getSort());
		newConstMenu.setMemo(tConstMenu.getMemo());
		newConstMenu.setModifyDate(new Date());

		newConstMenu.setReviser(tSysUser.getUserName());

		tConstMenuRepository.save(newConstMenu);
	}
//  TODO delete
//	/**
//	 * 函数功能说明： 前台菜单查询
//	 * 
//	 * @param 参数说明
//	 * @return 返回值说明 ：菜单集合
//	 * @throws 异常处理说明
//	 * @author 创建人 shangzl
//	 * @date 创建日期 2020-11-12
//	 */
//	public List<TConstMenu> queryFrontMenu(String strMenuName, String strType, String strChildMenu, String pageNumber,
//			String pageSize, HashMap<String, Integer> mapPage) {
//
////		不包含子菜单
//		if (strChildMenu == null) {
//
//			List<TConstMenu> lstConstMenu = tConstMenuRepository.findFrontByMenuName(strMenuName, strType,
//					mapPage.get("iTempPageNo"), mapPage.get("iPageSize"));
//			return lstConstMenu;
//
////			包含子菜单
//		} else {
//
//			List<TConstMenu> lstConstMenu = tConstMenuRepository.findFrontByMenuNameAndChild(strMenuName,
//					mapPage.get("iTempPageNo"), mapPage.get("iPageSize"));
//			return lstConstMenu;
//		}
//	}

// TODO delete
//	/**
//	 * 函数功能说明：后台菜单查询
//	 * 
//	 * @param 参数说明
//	 * @return 返回值说明 ：菜单集合
//	 * @throws 异常处理说明
//	 * @author 创建人 shangzl
//	 * @date 创建日期 2020-11-12
//	 */
//	public List<TConstMenu> queryBackMenu(String strMenuName, String strType, String strChildMenu, String pageNumber,
//			String pageSize, HashMap<String, Integer> mapPage) {
//
////		不包含子菜单
//		if (strChildMenu == null) {
//
//			List<TConstMenu> lstConstMenu = tConstMenuRepository.findBackByMenuName(strMenuName, strType,
//					mapPage.get("iTempPageNo"), mapPage.get("iPageSize"));
//			return lstConstMenu;
//
////			包含子菜单
//		} else {
//
//			List<TConstMenu> lstConstMenu = tConstMenuRepository.findBackByMenuNameAndChild(strMenuName, strMenuName,
//					mapPage.get("iTempPageNo"), mapPage.get("iPageSize"));
//			return lstConstMenu;
//		}
//
//	}

	/**
	 * 函数功能说明： 上移前台菜单
	 * 
	 * @param 参数说明
	 * @return 返回值说明：菜单集合
	 * @throws 异常处理说明
	 * @author 创建人 shangzl
	 * @date 创建日期 2020-11-12
	 */
	public List<TConstMenu> upFrontMenu(int iID, String strMenuName, String strType, String strChildMenu,
			String pageNumber, String pageSize, HashMap<String, Integer> mapPage) {

		if (strMenuName == null) {
			strMenuName = "";
		}
		if (strType == null) {
			strType = "";
		}
//		要移动的行
		TConstMenu newConstMenu = tConstMenuRepository.findByMenuID(iID);
		int idSort = newConstMenu.getSort();
//		移动的上一行
		if (newConstMenu.getType() == 1 && idSort > 1) {
			TConstMenu tConstMenu = tConstMenuRepository.findBySort((byte) (idSort - 1));
			int iSort = tConstMenu.getSort();
			int temp = idSort;
			idSort = iSort;
			iSort = temp;
			newConstMenu.setSort((byte) idSort);
			tConstMenu.setSort((byte) iSort);
			tConstMenuRepository.save(newConstMenu);
			tConstMenuRepository.save(tConstMenu);
		}

//		不包含子菜单
		if (strChildMenu == null) {

			List<TConstMenu> lstConstMenu = tConstMenuRepository.findFrontByMenuName(strMenuName, strType,
					mapPage.get("iTempPageNo"), mapPage.get("iPageSize"));
			return lstConstMenu;

//			包含子菜单
		} else {

			List<TConstMenu> lstConstMenu = tConstMenuRepository.findFrontByMenuNameAndChild(strMenuName, strMenuName,
					mapPage.get("iTempPageNo"), mapPage.get("iPageSize"));
			return lstConstMenu;
		}

	}

	/**
	 * 函数功能说明： 下移前台菜单
	 * 
	 * @param 参数说明
	 * @return 返回值说明 ：菜单集合
	 * @throws 异常处理说明
	 * @author 创建人 shangzl
	 * @date 创建日期 2020-11-12
	 */
	public List<TConstMenu> downFrontMenu(int iID, String strMenuName, String strType, String strChildMenu,
			String pageNumber, String pageSize, HashMap<String, Integer> mapPage) {

//		要移动的行
		TConstMenu newConstMenu = tConstMenuRepository.findByMenuID(iID);
		int idSort = newConstMenu.getSort();
		List<TConstMenu> lstConstMenu = new ArrayList<TConstMenu>();
//		不包含子菜单
		if (strChildMenu == null) {

			lstConstMenu = tConstMenuRepository.findFrontByMenuName(strMenuName, strType, mapPage.get("iTempPageNo"),
					mapPage.get("iPageSize"));

//			包含子菜单
		} else {

			lstConstMenu = tConstMenuRepository.findFrontByMenuNameAndChild(strMenuName, strMenuName,
					mapPage.get("iTempPageNo"), mapPage.get("iPageSize"));

		}
//		移动的下一行
		if (newConstMenu.getType() == 1 && idSort < tConstMenuRepository.findFront().size()) {
			TConstMenu tConstMenu = tConstMenuRepository.findBySort((byte) (idSort + 1));
			int iSort = tConstMenu.getSort();
			int temp = idSort;
			idSort = iSort;
			iSort = temp;
			newConstMenu.setSort((byte) idSort);
			tConstMenu.setSort((byte) iSort);
			tConstMenuRepository.save(newConstMenu);
			tConstMenuRepository.save(tConstMenu);
		}
		return lstConstMenu;
	}

	/**
	 * 函数功能说明： 上移后台菜单
	 * 
	 * @param 参数说明
	 * @return 返回值说明 ：菜单集合
	 * @throws 异常处理说明
	 * @author 创建人 shangzl
	 * @date 创建日期 2020-11-12
	 */
	public List<TConstMenu> upBackMenu(int iID, String strMenuName, String strType, String strChildMenu,
			String pageNumber, String pageSize, HashMap<String, Integer> mapPage) {
		List<TConstMenu> lstConstMenu = new ArrayList<TConstMenu>();
//		不包含子菜单
		if (strChildMenu == null) {

			lstConstMenu = tConstMenuRepository.findBackByMenuName(strMenuName, strType, mapPage.get("iTempPageNo"),
					mapPage.get("iPageSize"));

//			包含子菜单
		} else {

			lstConstMenu = tConstMenuRepository.findBackByMenuNameAndChild(strMenuName, strMenuName,
					mapPage.get("iTempPageNo"), mapPage.get("iPageSize"));

		}

//		要移动的行
		TConstMenu newConstMenu = tConstMenuRepository.findByMenuID(iID);
		int idSort = newConstMenu.getSort();

//		移动的上一行
		if (newConstMenu.getType() == 1 && idSort > tConstMenuRepository.findBack().get(0).getSort()) {
			TConstMenu tConstMenu = tConstMenuRepository.findBySort((byte) (idSort - 1));
			int iSort = tConstMenu.getSort();
			int temp = idSort;
			idSort = iSort;
			iSort = temp;
			newConstMenu.setSort((byte) idSort);
			tConstMenu.setSort((byte) iSort);
			tConstMenuRepository.save(newConstMenu);
			tConstMenuRepository.save(tConstMenu);
		} else if (newConstMenu.getType() == 0 && newConstMenu.getSort() > 1) {
			TConstMenu tConstMenu = tConstMenuRepository.findBySortUpMenuID(idSort - 1, newConstMenu.getUpMenuID());
			int iSort = tConstMenu.getSort();
			int temp = idSort;
			idSort = iSort;
			iSort = temp;
			newConstMenu.setSort((byte) idSort);
			tConstMenu.setSort((byte) iSort);
			tConstMenuRepository.save(newConstMenu);
			tConstMenuRepository.save(tConstMenu);
		}

		return lstConstMenu;
	}

	/**
	 * 函数功能说明： 下移后台菜单
	 * 
	 * @param 参数说明
	 * @return 返回值说明 ：菜单集合
	 * @throws 异常处理说明
	 * @author 创建人 shangzl
	 * @date 创建日期 2020-11-12
	 */
	public List<TConstMenu> downBackMenu(int iID, String strMenuName, String strType, String strChildMenu,
			String pageNumber, String pageSize, HashMap<String, Integer> mapPage) {
		List<TConstMenu> lstConstMenu = new ArrayList<TConstMenu>();
//		不包含子菜单
		if (strChildMenu == null) {

			lstConstMenu = tConstMenuRepository.findBackByMenuName(strMenuName, strType, mapPage.get("iTempPageNo"),
					mapPage.get("iPageSize"));

//			包含子菜单
		} else {

			lstConstMenu = tConstMenuRepository.findBackByMenuNameAndChild(strMenuName, strMenuName,
					mapPage.get("iTempPageNo"), mapPage.get("iPageSize"));

		}

//		要移动的行
		TConstMenu newConstMenu = tConstMenuRepository.findByMenuID(iID);
		int idSort = newConstMenu.getSort();
//		移动的下一行
		if (newConstMenu.getType() == 1 && idSort < tConstMenuRepository.countUpMenu()) {
			TConstMenu tConstMenu = tConstMenuRepository.findBySort((byte) (idSort + 1));
			int iSort = tConstMenu.getSort();
			int temp = idSort;
			idSort = iSort;
			iSort = temp;
			newConstMenu.setSort((byte) idSort);
			tConstMenu.setSort((byte) iSort);
			tConstMenuRepository.save(newConstMenu);
			tConstMenuRepository.save(tConstMenu);
		} else if (newConstMenu.getType() == 0
				&& newConstMenu.getSort() < tConstMenuRepository.findByUpMenuID(newConstMenu.getUpMenuID()).size()) {
			TConstMenu tConstMenu = tConstMenuRepository.findBySortUpMenuID(idSort + 1, newConstMenu.getUpMenuID());
			int iSort = tConstMenu.getSort();
			int temp = idSort;
			idSort = iSort;
			iSort = temp;
			newConstMenu.setSort((byte) idSort);
			tConstMenu.setSort((byte) iSort);
			tConstMenuRepository.save(newConstMenu);
			tConstMenuRepository.save(tConstMenu);
		}
		return lstConstMenu;
	}

	/**
	 * 函数功能说明： 查询前台菜单
	 * 
	 * @param 参数说明
	 * @return 返回值说明 ：菜单集合
	 * @throws 异常处理说明
	 * @author 创建人 shangzl
	 * @date 创建日期 2020-11-12
	 */
	public List<TConstMenu> frontMenu(String pageNumber, String pageSize, String strMenuName, String strType,
			String strChildMenu) {
		int iPageSize = 0;
		int iTempPageNo = 0;
		if (pageNumber == null) {
			pageNumber = "1";

		}
		if (strMenuName == null) {
			strMenuName = "";
		}
		if (strType == null) {
			strType = "";
		}
		if (pageSize == null) {
			iPageSize = 20;

		} else {
			iPageSize = Integer.valueOf(pageSize);
			iTempPageNo = (Integer.valueOf(pageNumber) - 1) * iPageSize;
		}

		List<TConstMenu> lstConstMenu = new ArrayList<TConstMenu>();

		if (strChildMenu == null) {

			lstConstMenu = tConstMenuRepository.findFrontByMenuName(strMenuName, strType, iTempPageNo, iPageSize);
		} else {

			lstConstMenu = tConstMenuRepository.findFrontByMenuNameAndChild(strMenuName, strMenuName, iTempPageNo,
					iPageSize);
		}
		return lstConstMenu;

	}

	/**
	 * 函数功能说明： 前台分页
	 * 
	 * @param 参数说明
	 * @return 返回值说明 ：map
	 * @throws 异常处理说明
	 * @author 创建人 shangzl
	 * @date 创建日期 2020-11-12
	 */

	public HashMap<String, Integer> mapFrontMenu(String pageNumber, String pageSize, String strMenuName, String strType,
			String strChildMenu) {

		if (strMenuName == null) {
			strMenuName = "";
		}
		if (strType == null) {
			strType = "";
		}

		Common common = new Common();
		HashMap<String, Integer> mapPage = new HashMap<String, Integer>();
		if (strChildMenu == null) {
			mapPage = common.getPage(pageNumber, pageSize,
					tConstMenuRepository.countFrontByMenuName(strMenuName, strType));

		} else {

			mapPage = common.getPage(pageNumber, pageSize,
					tConstMenuRepository.countFrontByMenuNameAndChild(strMenuName, strMenuName));

		}
		return mapPage;
	}

	/**
	 * 函数功能说明： 查询后台菜单
	 * 
	 * @param 参数说明
	 * @return 返回值说明 ：菜单集合
	 * @throws 异常处理说明
	 * @author 创建人 shangzl
	 * @date 创建日期 2020-11-12
	 */
	public List<TConstMenu> backMenu(String pageNumber, String pageSize, String strMenuName, String strType,
			String strChildMenu) {
		int iPageSize = 0;
		int iTempPageNo = 0;
		if (pageNumber == null) {
			pageNumber = "1";

		}
		if (strMenuName == null) {
			strMenuName = "";
		}
		if (strType == null) {
			strType = "";
		}
		if (pageSize == null) {
			iPageSize = 20;

		} else {
			iPageSize = Integer.valueOf(pageSize);
			iTempPageNo = (Integer.valueOf(pageNumber) - 1) * iPageSize;
		}

		List<TConstMenu> lstConstMenu = new ArrayList<TConstMenu>();

		if (strChildMenu == null) {
			lstConstMenu = tConstMenuRepository.findBackByMenuName(strMenuName, strType, iTempPageNo, iPageSize);
		} else {
			lstConstMenu = tConstMenuRepository.findBackByMenuNameAndChild(strMenuName, strMenuName, iTempPageNo,
					iPageSize);
		}
		return lstConstMenu;

	}

	/**
	 * 函数功能说明： 后台分页
	 * 
	 * @param 参数说明
	 * @return 返回值说明 ：map
	 * @throws 异常处理说明
	 * @author 创建人 shangzl
	 * @date 创建日期 2020-11-12
	 */

	public HashMap<String, Integer> mapBackMenu(String pageNumber, String pageSize, String strMenuName, String strType,
			String strChildMenu) {

		if (strMenuName == null) {
			strMenuName = "";
		}
		if (strType == null) {
			strType = "";
		}

		Common common = new Common();
		HashMap<String, Integer> mapPage = new HashMap<String, Integer>();
		if (strChildMenu == null) {
			mapPage = common.getPage(pageNumber, pageSize,
					tConstMenuRepository.countBackByMenuName(strMenuName, strType));

		} else {

			mapPage = common.getPage(pageNumber, pageSize,
					tConstMenuRepository.countBackByMenuNameAndChild(strMenuName, strMenuName));

		}
		return mapPage;
	}

}
